package com.zyl.Ecs.common.utils;

import lombok.SneakyThrows;
import org.springframework.beans.BeanUtils;
import org.springframework.util.StringUtils;

import java.util.Collection;
import java.util.Map;

/**
 * @version v1.0
 * @ProjectName: Ecs
 * @Package: com.zyl.Ecs.common.utils
 * @ClassName: OUtil
 * @Description TODO (对象工具类)
 * @Author 翟玉龙
 * @Date 2024/12/4-11:44
 */
public class ObjectUtil {


    /**
     * 复制属性到新对象（需传递目标对象）
     *
     * @param source 源对象
     * @param target 目标对象
     */
    public static void copyProperties(Object source, Object target) {
        BeanUtils.copyProperties(source, target);
    }

    /**
     * 复制属性到新对象（无需传递目标对象，自动根据类型创建）
     *
     * @param source 源对象
     * @param poType 目标对象类型
     * @return {@link T }
     */
    @SneakyThrows
    public static <T> T copyProperties(Object source, Class<T> poType) {
        if (ObjectUtil.isNull(source)) {
            return null;
        }
        /* 通过反射机制创建目标对象 */
        T target = poType.newInstance();
        /* 从源对象中复制属性到目标对象中 */
        BeanUtils.copyProperties(source, target);
        return target;
    }

    /**
     * 忽略大小写比较两字符串内容是否相同
     *
     * @param strA 字符串A
     * @param strB 字符串B
     * @return boolean
     */
    public static boolean equalsIgnoreCase(String strA, String strB) {
        if (isNull(strA)) {
            return false;
        }
        if (strA.equals(strB)) {
            return true;
        }
        return strA.equalsIgnoreCase(strB);
    }

    /**
     * 比较两对象是否相等
     *
     * @param objA 对象A
     * @param objB 对象B
     * @return boolean
     */
    public static boolean equals(Object objA, Object objB) {
        if (objA == objB) {
            return true;
        }
        if (isNull(objA)) {
            return false;
        }
        return objA.equals(objB);
    }

    public static boolean notEquals(Object objA, Object objB) {
        return !equals(objA, objB);
    }

    /**
     * 判断某个对象是否为空指针
     *
     * @param obj 要判断的对象
     * @return boolean
     */
    public static boolean isNull(Object obj) {
        return obj == null;
    }

    /**
     * 判断某个对象是否不为空指针
     *
     * @param obj 要判断的对象
     * @return boolean
     */
    public static boolean nonNull(Object obj) {
        return !isNull(obj);
    }

    /**
     * 判断某Collection集合是否为空
     *
     * @param collection 要判断的集合对象
     * @return boolean
     */
    public static boolean isEmpty(Collection<?> collection) {
        return isNull(collection) || collection.isEmpty();
    }
    /**
     * 判断某Map集合是否为空
     *
     * @param map 要判断的集合对象
     * @return boolean
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return isNull(map) || map.isEmpty();
    }

    /**
     * 判断某Collection集合是否不为空
     *
     * @param collection 要判断的集合对象
     * @return boolean
     */
    public static boolean nonEmpty(Collection<?> collection) {
        return !isEmpty(collection);
    }

    /**
     * 判断某Map集合是否不为空
     *
     * @param map 要判断的集合对象
     * @return boolean
     */
    public static boolean nonEmpty(Map<?, ?> map) {
        return !isEmpty(map);
    }

    /**
     * 判断某个字符串是否包含有效文本
     * 以下三种情况会返回false：
     * 1、值为null
     * 2、值为""
     * 3、所有字符均为空格符、回车符、换行符、制表符
     * @param s 要判断的字符串对象
     * @return boolean
     */
    public static boolean hasText(String s) {
        return StringUtils.hasText(s);
    }

    public static boolean notHasText(String s) {
        return !StringUtils.hasText(s);
    }

    /**
     * 判断多个条件是否同时满足
     *
     * @param expressions Expression
     * @return boolean
     */
    public static boolean and(boolean...expressions) {
        for (boolean expression : expressions) {
            if (!expression) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断多个条件是否满足任意一个
     *
     * @param expressions Expression
     * @return boolean
     */
    public static boolean or(boolean...expressions) {
        for (boolean expression : expressions) {
            if (expression) {
                return true;
            }
        }
        return false;
    }
}
